package com.itheima.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.common.R;
import com.itheima.dto.DishDto;
import com.itheima.entity.Dish;
import com.itheima.service.DishService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.security.PrivilegedExceptionAction;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author Tang
 * @date 2023/4/14
 */
@RequestMapping("/dish")
@RestController
public class DishController {

    @Autowired
    private DishService dishService;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 新增菜品
     *
     * @param dishDto
     * @return
     */
    //每次进行增加操作时为了保持数据一致，删除缓存的所有信息

    @PostMapping
    public R<String> addDish(@RequestBody DishDto dishDto) {
        //1.调用service新增方法
        dishService.addDishWithFalvors(dishDto);
        //1.1新增后将缓存的数据删除 保持和数据库一致
        String key ="dish_"+dishDto.getId()+"_"+dishDto.getStatus();
        redisTemplate.delete(key);
        //2.返回结果
        return R.success("新增菜品成功过！");
    }

    /**
     * 分页查询
     *
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    /*@GetMapping("/page")  嘴哥
    public R<Page<Dish>> page(@RequestParam(defaultValue = "1") Integer page,
                              @RequestParam(defaultValue = "10")Integer pageSize, String name){
        //0.分页拦截器【已经完成】
        //1.调用service的分页方法
        //1.1 构造分页对象Page(page, pageSize)
        Page<Dish> dishPage = new Page<>(page, pageSize);

        //1.2 构造查询条件，菜品名称
        LambdaQueryWrapper<Dish> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(name != null, Dish::getName, name);  //where name = null

        //1.3 调用service的分页方法
        dishService.page(dishPage, wrapper);

        //2.返回结果
        return R.success(dishPage);
    }*/
    @GetMapping("/page")
    public R<Page<DishDto>> page(@RequestParam(defaultValue = "1") Integer page,
                                 @RequestParam(defaultValue = "10") Integer pageSize, String name) {
        //0.分页拦截器【已经完成】
        //1.调用service的分页方法
        Page<DishDto> dishDtoPage = dishService.pageWithCategoryName(page, pageSize, name);

        //2.返回结果
        return R.success(dishDtoPage);
    }

    /**
     * 根据id查询菜品信息
     *
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<DishDto> getById(@PathVariable Long id) {
        //1.调用service查询方法
        DishDto dishDto = dishService.getDishWithFlavors(id);

        //2.返回结果
        return R.success(dishDto);
    }

    /**
     * 修改菜品
     *
     * @param dishDto
     * @return
     */
    //每次进行更改操作时为了保持数据一致，删除缓存的所有信息

    @PutMapping
    public R<String> update(@RequestBody DishDto dishDto) {
        //1.调用service修改方法
        dishService.updateWithFlavor(dishDto);
        //1.1更新后将缓存的对应数据删除
        String key ="dish_"+dishDto.getId()+"_"+dishDto.getStatus();
        redisTemplate.delete(key);
        //2.返回结果
        return R.success("修改菜品成功！");
    }

    /**
     * 查询菜品列表
     *
     * @param dish
     * @return
     */
    /*@GetMapping("/list")
    public R<List<Dish>> list(Dish dish) {
        //1.构造查询对象，设置查询条件  (条件可能是分类id，也可能是菜品名称)
        LambdaQueryWrapper<Dish> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(dish.getCategoryId() != null, Dish::getCategoryId, dish.getCategoryId());
        wrapper.like(dish.getName() != null, Dish::getName, dish.getName());

        //2.调用service的查询列表方法
        List<Dish> list = dishService.list(wrapper);

        //3.返回结果
        return R.success(list);
    }*/


    /**
     * 查询菜品列表
     * @param dish
     * @return
     */
    @GetMapping("/list")
    //缓存优化 先查询redis里有没有信息，没有再从数据库中找，找到后存入数据库

    public R<List<DishDto>> list(Dish dish) {

        //1.调用service的列表查询方法
        List<DishDto> dishDtos = dishService.listWithFlavors(dish);
        //1.1将高频访问数据存入redis中
        String key= "dish_"+dish.getId()+"_"+dish.getStatus();

        //2.返回结果
        return R.success(dishDtos);
    }
    //每次进行删除操作时为了保持数据一致，删除缓存的所有信息

    //根据ID 删除菜品
    @DeleteMapping
   public R<String> delete (@RequestParam List  ids ){
    boolean byIds = dishService.removeByIds(ids);
    if (byIds){
        //1.1删除后将缓存的数据删除 保持和数据库一致 由于是批量删除业务复杂直接全部清除
        Set keys = redisTemplate.keys("dish_*");
        redisTemplate.delete(keys);
        return  R.success("删除菜品成功");
    }
    return R.error("删除失败");
   }
 //根据ID和状态更改状态
 //每次进行更改操作时为了保持数据一致，删除缓存的所有信息

@PostMapping("status/{id}")
   public R<String> state(@PathVariable("id") Integer id ,@RequestParam List ids ){
     dishService.state(id,ids);
     if (id==0){
         Set keys = redisTemplate.keys("dish_*");
         redisTemplate.delete(keys);
         return R.success("起售成功");
     }
    Set keys = redisTemplate.keys("dish_*");
    redisTemplate.delete(keys);
     return R.success("停售成功");
}


}
